home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / DJGPP / DJ111M2.ZIP / go32 / utils.c < prev    next >
C/C++ Source or Header  |  1993-12-20  |  4KB  |  161 lines
  1. /* This is file UTILS.C */
  2. /*
  3. ** Copyright (C) 1993 DJ Delorie, 24 Kirsten Ave, Rochester NH 03867-2954
  4. **
  5. ** This file is distributed under the terms listed in the document
  6. ** "copying.dj", available from DJ Delorie at the address above.
  7. ** A copy of "copying.dj" should accompany this file; if not, a copy
  8. ** should be available from where this file was obtained.  This file
  9. ** may not be distributed without a verbatim copy of "copying.dj".
  10. **
  11. ** This file is distributed WITHOUT ANY WARRANTY; without even the implied
  12. ** warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13. */
  14.  
  15. /* History:130,1 */
  16.  
  17. #include <dos.h>
  18.  
  19. #include "gotypes.h"
  20. #include "tss.h"
  21. #include "gdt.h"
  22. #include "utils.h"
  23. #include "dpmi.h"
  24. #include "mswitch.h"
  25. #include "exphdlr.h"
  26.  
  27. extern void _do_memset32();
  28. extern void _do_memmov32();
  29. extern void _do_memscan32();
  30.  
  31. extern int was_exception;
  32.  
  33. TSS *utils_tss = &o_tss;
  34.  
  35. void go_til_stop(int allow_ret)
  36. {
  37.   while (1)
  38.   {
  39.     if (use_DPMI)
  40.     {
  41.       if (!DPMIexecute())
  42.         return;
  43.     }
  44.     else
  45.     {
  46.       go32();
  47.       if (!was_exception && allow_ret)
  48.         return;
  49.     }
  50.     if (exception_handler())
  51.       return;
  52.   }
  53. }
  54.  
  55. void zero32(word32 vaddr)
  56. {
  57.   TSS *old_ptr;
  58.   old_ptr = tss_ptr;
  59.   tss_ptr = utils_tss;
  60.   utils_tss->tss_eip = (word16)_do_memset32;
  61.   utils_tss->tss_eax = 0;
  62.   utils_tss->tss_ecx = 4096;
  63.   utils_tss->tss_es = g_core*8;
  64.   utils_tss->tss_edi = vaddr;
  65.   go_til_stop(1);
  66.   tss_ptr = old_ptr;
  67. }
  68.  
  69. void memput(word32 vaddr, void far *ptr, word16 len)
  70. {
  71.   if (use_DPMI)
  72.     Pmemput(tss_ptr->tss_ds, vaddr, (void *)ptr, len);
  73.   else {
  74.   TSS *old_ptr;
  75. /*  if (tss_ptr == &ed_tss)
  76.     vaddr += 0x90000000L; */
  77.   old_ptr = tss_ptr;
  78.   tss_ptr = utils_tss;
  79.   utils_tss->tss_eip = (word16)_do_memmov32;
  80.   utils_tss->tss_ecx = len;
  81.   utils_tss->tss_es = g_core*8;
  82.   utils_tss->tss_edi = vaddr;
  83.   utils_tss->tss_ds = g_core*8;
  84.   utils_tss->tss_esi = (word32)FP_SEG(ptr)*16 + (word32)FP_OFF(ptr);
  85.   go_til_stop(1);
  86.   tss_ptr = old_ptr;
  87.   }
  88. }
  89.  
  90. void memget(word32 vaddr, void far *ptr, word16 len)
  91. {
  92.   if (use_DPMI)
  93.     Pmemget(tss_ptr->tss_ds, vaddr, (void *)ptr, len);
  94.   else {
  95.   TSS *old_ptr;
  96. /*  if (tss_ptr == &ed_tss)
  97.     vaddr += 0x90000000L; */
  98.   old_ptr = tss_ptr;
  99.   tss_ptr = utils_tss;
  100.   utils_tss->tss_eip = (word16)_do_memmov32;
  101.   utils_tss->tss_ecx = len;
  102.   utils_tss->tss_es = g_core*8;
  103.   utils_tss->tss_edi = (word32)FP_SEG(ptr)*16 + (word32)FP_OFF(ptr);
  104.   utils_tss->tss_ds = g_core*8;
  105.   utils_tss->tss_esi = vaddr;
  106.   go_til_stop(1);
  107.   tss_ptr = old_ptr;
  108.   }
  109. }
  110.  
  111. void memscan32(word32 vaddr, void far *ptr, char term)
  112. {
  113.   TSS *old_ptr;
  114.   old_ptr = tss_ptr;
  115.   tss_ptr = utils_tss;
  116.   utils_tss->tss_ebx = term;
  117.   utils_tss->tss_eip = (word16)_do_memscan32;
  118.   utils_tss->tss_es = g_core*8;
  119.   utils_tss->tss_edi = (word32)FP_SEG(ptr)*16 + (word32)FP_OFF(ptr);
  120.   utils_tss->tss_ds = g_core*8;
  121.   utils_tss->tss_esi = vaddr;
  122.   go_til_stop(1);
  123.   tss_ptr = old_ptr;
  124. }
  125.  
  126. word32 peek32(word32 vaddr)
  127. {
  128.   word32 rv;
  129.   memget(vaddr, &rv, 4);
  130.   return rv;
  131. }
  132.  
  133. word16 peek16(word32 vaddr)
  134. {
  135.   word16 rv=0;
  136.   memget(vaddr, &rv, 2);
  137.   return rv;
  138. }
  139.  
  140. word8 peek8(word32 vaddr)
  141. {
  142.   word8 rv=0;
  143.   memget(vaddr, &rv, 1);
  144.   return rv;
  145. }
  146. /*
  147. void poke32(word32 vaddr, word32 v)
  148. {
  149.   memput(vaddr, &v, 4);
  150. }
  151.  
  152. void poke16(word32 vaddr, word16 v)
  153. {
  154.   memput(vaddr, &v, 2);
  155. }
  156.  
  157. void poke8(word32 vaddr, word8 v)
  158. {
  159.   memput(vaddr, &v, 1);
  160. } */
  161.